//
// Ishtar C++ Utility Library
//
// Task Facility - Thread Group Implementation
//

#include <Ishtar/Pch.h>

#include <Ishtar/Task/ThreadGroupImpl.h>


namespace Ishtar
{

namespace Task
{

///////////////////////////////////////////////////////////////////////////////
//
// Thread Group
//

ThreadGroupImpl::ThreadGroupImpl( ThreadGroup& host )
    : m_host( host )
{}

//void ThreadGroupImpl::Shutdown()
//{
//    ISHTAR_LOCK_MUTEX( m_mutex );
//    
//    m_threads.Shutdown( DEFAULT_TIMEOUT );
//}
//
//
//void ThreadGroupImpl::SubmitWork( const Work& w )
//{
//    Mutex::DeferLock lock( m_mutex );
//    
//    while ( !lock.TryLock() )
//    {
//        if ( m_threads.IsShutdown() )
//        {
//            {
//                ISHTAR_TRACE_WARN_HERE( "Thread group has been shutdown" );
//                ISHTAR_TRACE_INFO( "  workName: %s", w.Name() );
//            }
//                        
//            w.m_impl->AbortRun();
//            return;
//        }
//        
//        ThisThread::Yield();
//    }
//
//    w.m_impl->Setup( this );
//}
//
//
//void ThreadGroupImpl::AddReadyWork( const WorkImplPtr& work )
//{
//    m_threads.AddOnceThread(
//        work->Name(),
//        boost::bind( &ThreadGroupImpl::WorkWrapper, this, work )
//    );
//}
//
//
//void ThreadGroupImpl::WorkWrapper( const WorkImplPtr& work )
//{
//    if ( work->PrepareRun() )
//    {
//        work->Run();
//        work->CompleteRun();
//    }
//}
//
//
//void ThreadGroupImpl::AddThread(
//    const std::string& name, const Thread::ExecuteFunction& execFunc, Uint interval )
//{
//    ISHTAR_LOCK_MUTEX( m_mutex );
//    
//    m_threads.AddThread( name, execFunc, interval );
//}
//
//
//void ThreadGroupImpl::AddLoopThread(
//    const std::string& name, const Thread::VoidExecuteFunction& execFunc, Uint interval )
//{
//    ISHTAR_LOCK_MUTEX( m_mutex );
//    
//    m_threads.AddLoopThread( name, execFunc, interval );
//}
//
//
//void ThreadGroupImpl::AddOnceThread(
//    const std::string& name, const Thread::VoidExecuteFunction& execFunc )
//{
//    ISHTAR_LOCK_MUTEX( m_mutex );
//    
//    m_threads.AddOnceThread( name, execFunc );
//}
//
//
////
//// Bridging
////
//
//ThreadGroup::ThreadGroup()
//{
//    m_impl.reset( new ThreadGroupImpl( *this ));
//}
//
//
//void ThreadGroup::Shutdown()
//{
//    m_impl->Shutdown();
//}
//
//
//void ThreadGroup::SubmitWork( const Work& w )
//{
//    ISHTAR_ASSERT( !w.IsEmpty() );
//
//    m_impl->SubmitWork( w );
//}
//
//
//void ThreadGroup::AddThread(
//    const std::string& name, const Thread::ExecuteFunction& execFunc, Uint interval )
//{
//    m_impl->AddThread( name, execFunc, interval );
//}
//
//
//void ThreadGroup::AddLoopThread(
//    const std::string& name, const Thread::VoidExecuteFunction& execFunc, Uint interval )
//{
//    m_impl->AddLoopThread( name, execFunc, interval );
//}
//
//
//void ThreadGroup::AddOnceThread(
//    const std::string& name, const Thread::VoidExecuteFunction& execFunc )
//{
//    m_impl->AddOnceThread( name, execFunc );
//}
//
//
//Uint ThreadGroup::GetNumAliveThreads() const
//{
//    return m_impl->GetNumAliveThreads();
//}
//
//
//WorkExecutorImpl* ThreadGroup::GetImpl() const
//{
//    return m_impl.GetRawPointer();
//}


///////////////////////////////////////////////////////////////////////////////

} // namespace Task

} // namespace Ishtar
